export class ChatMessageBody {
  type: ChatMessageBodyType;
  value: string;

  constructor(args: { type: ChatMessageBodyType; value: string }) {
    this.type = args.type;
    this.value = args.value;
  }
}

// dev needs to specify/assign `type` and `value` multiple times

export interface ChatMessageBody {
  // only need to declare `type` and `value` in one place
  type: ChatMessageBodyType;
  value: string;
}
// ChatMessageBody is empty because constructor initialization is handled by BorshClass
export class ChatMessageBody extends BorshClass<ChatMessageBody> {}

export class ChatMessage {
  accountType = GovernanceChatAccountType.ChatMessage;

  proposal: PublicKey;
  author: PublicKey;
  postedAt: BN;
  replyTo: PublicKey | undefined;
  body: ChatMessageBody;

  constructor(args: {
    proposal: PublicKey;
    author: PublicKey;
    postedAt: BN;
    replyTo: PublicKey | undefined;
    body: ChatMessageBody;
  }) {
    this.proposal = args.proposal;
    this.author = args.author;
    this.postedAt = args.postedAt;
    this.replyTo = args.replyTo;
    this.body = args.body;
  }
}

// intermediary interface declared as extra property `accountType` is not to be passed to the constructor
interface ChatMessageProps {
  proposal: PublicKey;
  author: PublicKey;
  postedAt: BN;
  replyTo?: PublicKey;  // ? makes `| undefined` union type redundant
  body: ChatMessageBody;
}
// export interface as in example 1, effectively a union of ChatMessageProps above, and ChatMessage below
export interface ChatMessage extends ChatMessageProps {}
export class ChatMessage extends BorshClass<ChatMessageProps> {
  // add properties and methods as usual, which will not to be passed in as args to the constructor
  accountType = GovernanceChatAccountType.ChatMessage;
}